<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Kafka时间轮实现详解 | 技术小馆</title>
    <link href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css" rel="stylesheet">
    <link href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css" rel="stylesheet">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <style>
        body {
            font-family: 'Noto Sans SC', Tahoma, Arial, Roboto, "Droid Sans", "Helvetica Neue", "Droid Sans Fallback", "Heiti SC", "Hiragino Sans GB", Simsun, sans-serif;
            color: #333;
            line-height: 1.6;
            background-color: #f8f9fa;
        }
        h1, h2, h3, h4, h5, h6 {
            font-family: 'Noto Serif SC', serif;
            font-weight: 600;
            color: #1a1a1a;
            margin-top: 2rem;
            margin-bottom: 1rem;
        }
        .hero {
            background: linear-gradient(135deg, #1e3c72 0%, #2a5298 100%);
            color: white;
        }
        .card {
            transition: all 0.3s ease;
            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.05);
        }
        .card:hover {
            transform: translateY(-4px);
            box-shadow: 0 10px 15px rgba(0, 0, 0, 0.1);
        }
        .highlight {
            background-color: rgba(255, 229, 100, 0.3);
            padding: 0.2em 0.4em;
            border-radius: 3px;
        }
        .divider {
            height: 1px;
            background: linear-gradient(to right, transparent, rgba(0,0,0,0.1), transparent);
            margin: 2rem 0;
        }
        .mermaid {
            background-color: white;
            padding: 1.5rem;
            border-radius: 8px;
            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.05);
            margin: 1.5rem 0;
        }
        .feature-icon {
            font-size: 2rem;
            color: #3b82f6;
            margin-bottom: 1rem;
        }
        .pros-cons {
            border-radius: 8px;
            overflow: hidden;
            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.05);
        }
        .pros {
            background-color: rgba(74, 222, 128, 0.1);
        }
        .cons {
            background-color: rgba(248, 113, 113, 0.1);
        }
        .footer {
            background-color: #1a1a1a;
        }
        a:hover {
            color: #3b82f6;
            text-decoration: underline;
        }
        .back-to-top {
            position: fixed;
            bottom: 2rem;
            right: 2rem;
            width: 50px;
            height: 50px;
            border-radius: 50%;
            background-color: #3b82f6;
            color: white;
            display: flex;
            align-items: center;
            justify-content: center;
            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
            transition: all 0.3s ease;
            opacity: 0;
            visibility: hidden;
        }
        .back-to-top.visible {
            opacity: 1;
            visibility: visible;
        }
        .back-to-top:hover {
            background-color: #2563eb;
            transform: translateY(-2px);
        }
    </style>
</head>
<body class="antialiased">
    <!-- Hero Section -->
    <section class="hero py-20 px-4 md:px-0">
        <div class="container mx-auto max-w-5xl text-center">
            <h1 class="text-4xl md:text-5xl font-bold mb-6">Kafka时间轮的实现原理与应用</h1>
            <p class="text-xl md:text-2xl opacity-90 mb-8">高效定时任务调度的核心技术解析</p>
            <div class="flex justify-center space-x-4">
                <a href="#concept" class="px-6 py-3 bg-white text-blue-800 font-medium rounded-full hover:bg-gray-100 transition duration-300">
                    <i class="fas fa-book mr-2"></i>核心概念
                </a>
                <a href="#implementation" class="px-6 py-3 bg-transparent border-2 border-white text-white font-medium rounded-full hover:bg-white hover:text-blue-800 transition duration-300">
                    <i class="fas fa-code mr-2"></i>实现细节
                </a>
            </div>
        </div>
    </section>

    <!-- Main Content -->
    <main class="container mx-auto max-w-5xl px-4 md:px-0 py-12">
        <!-- Introduction -->
        <section class="mb-16">
            <p class="text-lg mb-6 leading-relaxed">
                在分布式系统中，尤其是在高吞吐量的消息队列系统如Kafka中，处理定时任务和延迟消息是一个关键的挑战。时间轮作为一种高效的定时任务调度机制，能够在这些复杂的环境中提供卓越的性能和灵活性。
            </p>
            <div class="flex justify-center my-8">
                <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1724474055247-f3b54b72-6af5-42d6-86a3-863e4797de4c.png" alt="Kafka时间轮示意图" class="rounded-lg shadow-lg max-w-full h-auto">
            </div>
            <p class="text-lg leading-relaxed">
                Kafka不仅需要处理不断涌入的消息，还需要高效地管理各种定时任务，比如消息的延迟投递、重试策略和过期消息的清理。这些任务的调度和管理直接影响到系统的整体性能和用户体验。时间轮作为一种用于管理定时任务的数据结构，能够以高效的方式处理大量的定时任务。
            </p>
        </section>

        <!-- Concept Section -->
        <section id="concept" class="mb-16">
            <h2 class="text-3xl font-bold mb-8 flex items-center">
                <i class="fas fa-lightbulb text-yellow-500 mr-3"></i>
                时间轮的概念
            </h2>
            <p class="mb-6">
                时间轮（Time Wheel）是一种用于高效处理定时任务的数据结构，它解决了传统定时器在处理大量定时任务时可能遇到的性能瓶颈问题。时间轮在系统中的应用非常广泛，特别是在需要处理大量定时任务和事件的分布式系统中，如消息队列、调度系统等。
            </p>
            <div class="flex justify-center my-8">
                <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1724473719261-2077c6f2-e5d7-4f9d-be76-7db4bc8548e0.png" alt="时间轮基本概念" class="rounded-lg shadow-lg max-w-full h-auto">
            </div>

            <h3 class="text-2xl font-semibold mt-10 mb-4">1. 时间轮的基本概念</h3>
            <p class="mb-6">
                时间轮是一种以轮状结构组织的定时任务调度机制。其核心思想是将时间划分为若干个固定长度的时间片段，并以环形的方式将这些时间片段连接起来。每个时间片段代表一个时间单位，时间轮的结构可以视为一个环形的列表，其中每个位置代表一个时间槽（Slot）。
            </p>
            
            <div class="grid md:grid-cols-2 gap-6 my-8">
                <div class="card bg-white p-6 rounded-lg">
                    <h4 class="text-xl font-semibold mb-3 flex items-center">
                        <i class="fas fa-clock text-blue-500 mr-2"></i>
                        时间槽（Slot）
                    </h4>
                    <p>时间轮中的基本单位，每个时间槽可以存储在该时间段内需要执行的任务。时间槽的数量决定了时间轮的分辨率，即时间轮能够处理的最小时间粒度。</p>
                </div>
                <div class="card bg-white p-6 rounded-lg">
                    <h4 class="text-xl font-semibold mb-3 flex items-center">
                        <i class="fas fa-arrow-pointer text-blue-500 mr-2"></i>
                        时间轮指针
                    </h4>
                    <p>一个指向当前时间槽的指针，用于跟踪时间的流逝和任务的执行。时间轮的指针会随着时间的推移而周期性地移动，从而更新当前时间槽的位置。</p>
                </div>
            </div>

            <h3 class="text-2xl font-semibold mt-10 mb-4">2. 时间轮的工作原理</h3>
            <p class="mb-4">
                时间轮的工作机制基于时间的周期性流逝。其基本工作流程如下：
            </p>
            <div class="grid md:grid-cols-2 gap-6 my-8">
                <div class="card bg-white p-6 rounded-lg">
                    <h4 class="text-xl font-semibold mb-3">任务插入</h4>
                    <p>当一个新的定时任务被添加到时间轮中时，系统会计算出任务的执行时间相对于当前时间的偏移量。然后将任务插入到相应的时间槽中。</p>
                </div>
                <div class="card bg-white p-6 rounded-lg">
                    <h4 class="text-xl font-semibold mb-3">时间推进</h4>
                    <p>时间轮的指针周期性地移动，每次移动一个时间槽的距离。当时间轮指针移动到一个新的时间槽时，该时间槽中的所有任务都会被取出并执行。</p>
                </div>
                <div class="card bg-white p-6 rounded-lg">
                    <h4 class="text-xl font-semibold mb-3">任务执行</h4>
                    <p>当时间轮指针到达一个时间槽时，该时间槽中的所有任务都会被触发并执行。任务的执行通常是按顺序进行的，系统会逐个处理时间槽中的任务。</p>
                </div>
                <div class="card bg-white p-6 rounded-lg">
                    <h4 class="text-xl font-semibold mb-3">任务移除和更新</h4>
                    <p>执行完的任务会被从时间槽中移除。如果任务需要重新调度，系统会计算任务的新时间槽位置，并将其插入到新的时间槽中。</p>
                </div>
            </div>

            <h3 class="text-2xl font-semibold mt-10 mb-4">3. 时间轮的优势</h3>
            <p class="mb-6">
                时间轮相比于传统的优先队列和哈希表等定时任务调度机制，具有以下优势：
            </p>
            <div class="grid md:grid-cols-3 gap-6 my-8">
                <div class="card bg-white p-6 rounded-lg text-center">
                    <div class="feature-icon">
                        <i class="fas fa-bolt"></i>
                    </div>
                    <h4 class="text-lg font-semibold mb-2">高效的时间复杂度</h4>
                    <p class="text-sm">任务插入、删除和查找操作都具有常数时间复杂度O(1)。</p>
                </div>
                <div class="card bg-white p-6 rounded-lg text-center">
                    <div class="feature-icon">
                        <i class="fas fa-memory"></i>
                    </div>
                    <h4 class="text-lg font-semibold mb-2">减少内存开销</h4>
                    <p class="text-sm">使用固定数量的时间槽来存储任务，避免了为每个任务分配额外的内存。</p>
                </div>
                <div class="card bg-white p-6 rounded-lg text-center">
                    <div class="feature-icon">
                        <i class="fas fa-users"></i>
                    </div>
                    <h4 class="text-lg font-semibold mb-2">适用于高并发场景</h4>
                    <p class="text-sm">环形结构和固定时间槽的设计能够有效避免锁竞争和性能瓶颈。</p>
                </div>
            </div>
        </section>

        <div class="divider"></div>

        <!-- Principle Section -->
        <section id="principle" class="mb-16">
            <h2 class="text-3xl font-bold mb-8 flex items-center">
                <i class="fas fa-cogs text-blue-500 mr-3"></i>
                时间轮的基本原理
            </h2>
            <p class="mb-6">
                时间轮（Time Wheel）是一种用于高效管理和调度定时任务的数据结构，特别适用于处理大量定时任务的场景。它通过将时间划分为固定长度的时间片段，并以环形结构组织这些时间片段，提供了一种高效的定时任务调度机制。
            </p>
            <div class="flex justify-center my-8">
                <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1724473921743-bb72e696-af54-4b34-9508-d3695947bafa.png" alt="时间轮原理图" class="rounded-lg shadow-lg max-w-full h-auto">
            </div>

            <h3 class="text-2xl font-semibold mt-10 mb-4">1. 时间轮的设计思想</h3>
            <p class="mb-6">
                时间轮的设计思想源于对传统定时器的改进，特别是在处理大量定时任务时的性能优化。其基本理念是通过将时间划分为若干个时间槽，并使用环形的数据结构来存储和管理这些任务，从而实现时间复杂度的优化和内存利用的高效性。
            </p>

            <div class="grid md:grid-cols-2 gap-6 my-8">
                <div class="card bg-white p-6 rounded-lg">
                    <h4 class="text-xl font-semibold mb-3 flex items-center">
                        <i class="fas fa-puzzle-piece text-blue-500 mr-2"></i>
                        时间槽（Slot）
                    </h4>
                    <p>时间轮中的基本单位，每个时间槽代表一个固定长度的时间段。时间槽的数量决定了时间轮的分辨率，即它能处理的最小时间粒度。</p>
                </div>
                <div class="card bg-white p-6 rounded-lg">
                    <h4 class="text-xl font-semibold mb-3 flex items-center">
                        <i class="fas fa-arrows-alt-h text-blue-500 mr-2"></i>
                        时间轮指针
                    </h4>
                    <p>一个指向当前时间槽的指针，用于跟踪时间的流逝。时间轮的指针会以固定的步长循环移动，每次移动一个时间槽的距离，模拟时间的流逝。</p>
                </div>
            </div>

            <h3 class="text-2xl font-semibold mt-10 mb-4">2. 时间轮的核心组件</h3>
            <p class="mb-6">
                时间轮的核心组件包括时间轮本身、时间槽以及时间轮指针。每个组件的作用如下：
            </p>

            <div class="mermaid">
                graph TD
                    A[时间轮 Time Wheel] --> B[时间槽 Slot]
                    A --> C[时间轮指针 Pointer]
                    B --> D[存储任务]
                    C --> E[跟踪时间流逝]
            </div>

            <h3 class="text-2xl font-semibold mt-10 mb-4">3. 时间轮的工作机制</h3>
            <p class="mb-6">
                时间轮的工作机制主要包括任务的插入、时间的推进和任务的执行三个步骤。
            </p>

            <div class="grid md:grid-cols-3 gap-6 my-8">
                <div class="card bg-white p-6 rounded-lg">
                    <h4 class="text-xl font-semibold mb-3 flex items-center">
                        <span class="bg-blue-500 text-white rounded-full w-8 h-8 flex items-center justify-center mr-3">1</span>
                        任务插入
                    </h4>
                    <ol class="list-decimal pl-5 space-y-2">
                        <li>计算时间偏移</li>
                        <li>计算时间槽索引</li>
                        <li>插入任务</li>
                    </ol>
                </div>
                <div class="card bg-white p-6 rounded-lg">
                    <h4 class="text-xl font-semibold mb-3 flex items-center">
                        <span class="bg-blue-500 text-white rounded-full w-8 h-8 flex items-center justify-center mr-3">2</span>
                        时间推进
                    </h4>
                    <ol class="list-decimal pl-5 space-y-2">
                        <li>指针移动</li>
                        <li>任务执行</li>
                        <li>任务重新调度</li>
                    </ol>
                </div>
                <div class="card bg-white p-6 rounded-lg">
                    <h4 class="text-xl font-semibold mb-3 flex items-center">
                        <span class="bg-blue-500 text-white rounded-full w-8 h-8 flex items-center justify-center mr-3">3</span>
                        任务执行
                    </h4>
                    <ol class="list-decimal pl-5 space-y-2">
                        <li>任务遍历</li>
                        <li>任务触发</li>
                        <li>任务移除</li>
                    </ol>
                </div>
            </div>
        </section>

        <div class="divider"></div>

        <!-- Kafka Implementation Section -->
        <section id="implementation" class="mb-16">
            <h2 class="text-3xl font-bold mb-8 flex items-center">
                <i class="fab fa-kafka text-purple-500 mr-3"></i>
                Kafka中时间轮的设计
            </h2>
            <p class="mb-6">
                在Kafka中，时间轮（Time Wheel）主要用于处理消息的延迟投递、定时任务和过期消息的清理。Kafka作为一个高性能的分布式消息系统，要求其内部机制必须高效且可扩展，以应对大量的消息和定时任务。
            </p>

            <h3 class="text-2xl font-semibold mt-10 mb-4">1. 设计目标</h3>
            <div class="grid md:grid-cols-3 gap-4 my-6">
                <div class="bg-blue-50 p-4 rounded-lg">
                    <p class="font-medium">高效的定时任务调度</p>
                    <p class="text-sm text-gray-600">处理大量的定时任务和消息延迟投递</p>
                </div>
                <div class="bg-blue-50 p-4 rounded-lg">
                    <p class="font-medium">低延迟和高吞吐量</p>
                    <p class="text-sm text-gray-600">在高并发环境下保持系统性能的稳定性</p>
                </div>
                <div class="bg-blue-50 p-4 rounded-lg">
                    <p class="font-medium">内存和资源的优化利用</p>
                    <p class="text-sm text-gray-600">高效使用系统资源，减少不必要的开销</p>
                </div>
            </div>

            <h3 class="text-2xl font-semibold mt-10 mb-4">2. Kafka时间轮的核心组件</h3>
            <div class="grid md:grid-cols-3 gap-6 my-8">
                <div class="card bg-white p-6 rounded-lg">
                    <h4 class="text-xl font-semibold mb-3">时间轮（Time Wheel）</h4>
                    <p>Kafka中的时间轮是一个环形的数据结构，由若干个时间槽（Slot）组成。每个时间槽代表一个固定的时间单位，例如一秒钟。</p>
                </div>
                <div class="card bg-white p-6 rounded-lg">
                    <h4 class="text-xl font-semibold mb-3">时间槽（Slot）</h4>
                    <p>时间槽是时间轮中的基本单位，用于存储需要在特定时间段内执行的任务。</p>
                </div>
                <div class="card bg-white p-6 rounded-lg">
                    <h4 class="text-xl font-semibold mb-3">时间轮指针</h4>
                    <p>时间轮指针是一个指向当前时间槽的指针，模拟时间的流逝。</p>
                </div>
            </div>

            <h3 class="text-2xl font-semibold mt-10 mb-4">3. Kafka时间轮的设计实现</h3>
            <div class="space-y-8">
                <div>
                    <h4 class="text-xl font-semibold mb-3 flex items-center">
                        <span class="bg-purple-500 text-white rounded-full w-6 h-6 flex items-center justify-center mr-3">1</span>
                        延迟投递和过期消息处理
                    </h4>
                    <div class="grid md:grid-cols-2 gap-6">
                        <div class="bg-white p-4 rounded-lg">
                            <p class="font-medium mb-2">延迟投递</p>
                            <p>消息的延迟投递是通过将消息放入未来的时间槽中来实现的。当时间轮指针到达对应的时间槽时，消息会被取出并投递到目标消费者。</p>
                        </div>
                        <div class="bg-white p-4 rounded-lg">
                            <p class="font-medium mb-2">过期清理</p>
                            <p>时间轮也用于定期清理过期的消息。过期消息会在时间轮指针到达相应时间槽时被删除，从而释放系统资源。</p>
                        </div>
                    </div>
                </div>
                
                <div>
                    <h4 class="text-xl font-semibold mb-3 flex items-center">
                        <span class="bg-purple-500 text-white rounded-full w-6 h-6 flex items-center justify-center mr-3">2</span>
                        重试机制
                    </h4>
                    <div class="grid md:grid-cols-2 gap-6">
                        <div class="bg-white p-4 rounded-lg">
                            <p class="font-medium mb-2">重试任务调度</p>
                            <p>重试任务会根据消息的重试时间被插入到时间轮的相应时间槽中。当时间轮指针到达重试时间槽时，重试任务会被触发并执行。</p>
                        </div>
                        <div class="bg-white p-4 rounded-lg">
                            <p class="font-medium mb-2">重试策略</p>
                            <p>Kafka允许配置重试次数和间隔时间，以控制重试的频率和策略。时间轮设计需要支持这些灵活的配置选项。</p>
                        </div>
                    </div>
                </div>
                
                <div>
                    <h4 class="text-xl font-semibold mb-3 flex items-center">
                        <span class="bg-purple-500 text-white rounded-full w-6 h-6 flex items-center justify-center mr-3">3</span>
                        性能优化
                    </h4>
                    <div class="grid md:grid-cols-3 gap-4">
                        <div class="bg-white p-4 rounded-lg">
                            <p class="font-medium mb-2">多层时间轮</p>
                            <p>引入秒级、分钟级、小时级时间轮的层级设计可以支持不同粒度的定时任务。</p>
                        </div>
                        <div class="bg-white p-4 rounded-lg">
                            <p class="font-medium mb-2">分段锁</p>
                            <p>在高并发环境中，使用分段锁机制来减少锁竞争，提高任务调度的并发性。</p>
                        </div>
                        <div class="bg-white p-4 rounded-lg">
                            <p class="font-medium mb-2">优化任务存储</p>
                            <p>选择合适的数据结构（如链表、优先队列）来存储任务，以优化插入、删除和遍历操作的性能。</p>
                        </div>
                    </div>
                </div>
            </div>
        </section>

        <div class="divider"></div>

        <!-- Application Section -->
        <section id="application" class="mb-16">
            <h2 class="text-3xl font-bold mb-8 flex items-center">
                <i class="fas fa-th-large text-green-500 mr-3"></i>
                Kafka时间轮的应用场景
            </h2>
            <p class="mb-6">
                Kafka时间轮（Time Wheel）在实际应用中主要用于处理延迟消息、定时任务、重试机制和过期消息管理等场景。
            </p>

            <div class="grid md:grid-cols-2 gap-6 my-8">
                <div class="card bg-white p-6 rounded-lg">
                    <h4 class="text-xl font-semibold mb-3 flex items-center">
                        <i class="fas fa-clock text-green-500 mr-3"></i>
                        延迟消息处理
                    </h4>
                    <p>延迟消息是指在某个特定的时间之后才需要被处理的消息。这在许多应用场景中是常见的，例如定时任务、定期通知和延迟提醒等。</p>
                </div>
                <div class="card bg-white p-6 rounded-lg">
                    <h4 class="text-xl font-semibold mb-3 flex items-center">
                        <i class="fas fa-tasks text-green-500 mr-3"></i>
                        定时任务调度
                    </h4>
                    <p>定时任务是指在预定时间或时间间隔内需要执行的任务。这在许多场景中都是必需的，例如定期数据清理、定时报告生成等。</p>
                </div>
                <div class="card bg-white p-6 rounded-lg">
                    <h4 class="text-xl font-semibold mb-3 flex items-center">
                        <i class="fas fa-redo text-green-500 mr-3"></i>
                        重试机制
                    </h4>
                    <p>在分布式系统中，消息的发送或处理可能会由于临时故障而失败。重试机制用于在失败后重新尝试消息的处理。</p>
                </div>
                <div class="card bg-white p-6 rounded-lg">
                    <h4 class="text-xl font-semibold mb-3 flex items-center">
                        <i class="fas fa-trash-alt text-green-500 mr-3"></i>
                        过期消息清理
                    </h4>
                    <p>在消息系统中，过期消息指的是已经超过有效期的消息，这些消息不再需要处理，需要从系统中清理以释放资源。</p>
                </div>
            </div>
        </section>

        <div class="divider"></div>

        <!-- Pros & Cons Section -->
        <section id="pros-cons" class="mb-16">
            <h2 class="text-3xl font-bold mb-8 flex items-center">
                <i class="fas fa-balance-scale text-orange-500 mr-3"></i>
                时间轮的优缺点
            </h2>
            <p class="mb-6">
                时间轮（Time Wheel）是一种用于高效调度定时任务和管理延迟消息的数据结构，其设计旨在优化任务调度的性能，特别是在处理大量定时任务时。
            </p>

            <div class="pros-cons grid md:grid-cols-2 my-8">
                <div class="pros p-6">
                    <h3 class="text-2xl font-semibold mb-4 flex items-center">
                        <i class="fas fa-thumbs-up text-green-500 mr-2"></i>
                        优点
                    </h3>
                    <ul class="space-y-4">
                        <li class="flex items-start">
                            <span class="bg-green-500 text-white rounded-full w-5 h-5 flex items-center justify-center flex-shrink-0 mr-3 mt-1">
                                <i class="fas fa-check text-xs"></i>
                            </span>
                            <div>
                                <h4 class="font-semibold">高效的时间复杂度</h4>
                                <p class="text-sm">任务插入、删除和查找操作都具有常数时间复杂度 ( O(1) )，无论任务数量的多少。</p>
                            </div>
                        </li>
                        <li class="flex items-start">
                            <span class="bg-green-500 text-white rounded-full w-5 h-5 flex items-center justify-center flex-shrink-0 mr-3 mt-1">
                                <i class="fas fa-check text-xs"></i>
                            </span>
                            <div>
                                <h4 class="font-semibold">资源利用的优化</h4>
                                <p class="text-sm">时间轮通过固定数量的时间槽来存储任务，这种固定结构可以有效地利用内存和资源。</p>
                            </div>
                        </li>
                        <li class="flex items-start">
                            <span class="bg-green-500 text-white rounded-full w-5 h-5 flex items-center justify-center flex-shrink-0 mr-3 mt-1">
                                <i class="fas fa-check text-xs"></i>
                            </span>
                            <div>
                                <h4 class="font-semibold">简化的任务调度</h4>
                                <p class="text-sm">时间轮通过将时间划分为固定长度的时间槽，简化了任务调度的复杂性。</p>
                            </div>
                        </li>
                        <li class="flex items-start">
                            <span class="bg-green-500 text-white rounded-full w-5 h-5 flex items-center justify-center flex-shrink-0 mr-3 mt-1">
                                <i class="fas fa-check text-xs"></i>
                            </span>
                            <div>
                                <h4 class="font-semibold">支持高并发</h4>
                                <p class="text-sm">通过将任务分配到不同的时间槽，减少了任务之间的竞争和锁的争用。</p>
                            </div>
                        </li>
                    </ul>
                </div>
                <div class="cons p-6">
                    <h3 class="text-2xl font-semibold mb-4 flex items-center">
                        <i class="fas fa-thumbs-down text-red-500 mr-2"></i>
                        缺点
                    </h3>
                    <ul class="space-y-4">
                        <li class="flex items-start">
                            <span class="bg-red-500 text-white rounded-full w-5 h-5 flex items-center justify-center flex-shrink-0 mr-3 mt-1">
                                <i class="fas fa-times text-xs"></i>
                            </span>
                            <div>
                                <h4 class="font-semibold">时间粒度限制</h4>
                                <p class="text-sm">时间轮的时间粒度由时间槽的数量决定。如果需要更高精度的定时任务，时间槽的数量必须增加。</p>
                            </div>
                        </li>
                        <li class="flex items-start">
                            <span class="bg-red-500 text-white rounded-full w-5 h-5 flex items-center justify-center flex-shrink-0 mr-3 mt-1">
                                <i class="fas fa-times text-xs"></i>
                            </span>
                            <div>
                                <h4 class="font-semibold">时间槽容量限制</h4>
                                <p class="text-sm">每个时间槽的容量有限，如果某个时间槽中任务过多，可能会导致性能问题。</p>
                            </div>
                        </li>
                        <li class="flex items-start">
                            <span class="bg-red-500 text-white rounded-full w-5 h-5 flex items-center justify-center flex-shrink-0 mr-3 mt-1">
                                <i class="fas fa-times text-xs"></i>
                            </span>
                            <div>
                                <h4 class="font-semibold">复杂的任务再调度</h4>
                                <p class="text-sm">对于需要在时间轮外部重新调度的任务，时间轮可能需要额外的逻辑来处理任务的重新插入或调整。</p>
                            </div>
                        </li>
                        <li class="flex items-start">
                            <span class="bg-red-500 text-white rounded-full w-5 h-5 flex items-center justify-center flex-shrink-0 mr-3 mt-1">
                                <i class="fas fa-times text-xs"></i>
                            </span>
                            <div>
                                <h4 class="font-semibold">固定内存消耗</h4>
                                <p class="text-sm">时间轮的内存消耗是固定的，无法根据实际任务负载动态调整。</p>
                            </div>
                        </li>
                    </ul>
                </div>
            </div>
        </section>
    </main>

    <!-- Footer -->
    <footer class="footer text-white py-8">
        <div class="container mx-auto max-w-5xl px-4 md:px-0">
            <div class="flex flex-col md:flex-row justify-between items-center">
                <div class="mb-4 md:mb-0">
                    <h3 class="text-xl font-bold">技术小馆</h3>
                    <p class="text-gray-400 mt-1">探索技术之美，分享知识之光</p>
                </div>
                <div>
                    <a href="http://www.yuque.com/jtostring" class="hover:text-blue-300 transition duration-300">
                        <i class="fas fa-link mr-2"></i>http://www.yuque.com/jtostring
                    </a>
                </div>
            </div>
        </div>
    </footer>

    <!-- Back to Top Button -->
    <a href="#" class="back-to-top" id="backToTop">
        <i class="fas fa-arrow-up"></i>
    </a>

    <script>
        // Initialize Mermaid
        mermaid.initialize({
            startOnLoad: true,
            theme: 'default',
            flowchart: {
                useMaxWidth: false,
                htmlLabels: true,
                curve: 'basis'
            }
        });

        // Back to top button
        const backToTopButton = document.getElementById('backToTop');
        window.addEventListener('scroll', () => {
            if (window.pageYOffset > 300) {
                backToTopButton.classList.add('visible');
            } else {
                backToTopButton.classList.remove('visible');
            }
        });

        // Smooth scrolling for anchor links
        document.querySelectorAll('a[href^="#"]').forEach(anchor => {
            anchor.addEventListener('click', function (e) {
                e.preventDefault();
                document.querySelector(this.getAttribute('href')).scrollIntoView({
                    behavior: 'smooth'
                });
            });
        });

        // Card hover effect enhancement
        document.querySelectorAll('.card').forEach(card => {
            card.addEventListener('mouseenter', function() {
                this.style.transform = 'translateY(-4px)';
                this.style.boxShadow = '0 10px 15px rgba(0, 0, 0, 0.1)';
            });
            card.addEventListener('mouseleave', function() {
                this.style.transform = '';
                this.style.boxShadow = '';
            });
        });
    </script>
</body>
</html>